tests/markdown/check-markdown.test.js (3)

83-86: Avoid using await inside a loop for better performance

Using await inside a loop can cause the iterations to run sequentially, which may impact performance. Consider using Promise.all to execute these asynchronous operations concurrently.

Apply this diff to refactor the code:

- for (let i = 0; i < 20; i++) {
-   await fs.writeFile(
-     path.join(tempDir, `test${i}.md`),
-     '---\ntitle: Test\n---'
-   );
- }
+ const writePromises = [];
+ for (let i = 0; i < 20; i++) {
+   writePromises.push(
+     fs.writeFile(
+       path.join(tempDir, `test${i}.md`),
+       '---\ntitle: Test\n---'
+     )
+   );
+ }
+ await Promise.all(writePromises);

🧰 Tools

🪛 eslint

[error] 83-86: Unexpected await inside a loop.

(no-await-in-loop)

---

[error] 83-86: Replace ⏎··········path.join(tempDir,·test${i}.md),⏎··········'---\ntitle:·Test\n---'⏎········ with path.join(tempDir,·test${i}.md),·'---\ntitle:·Test\n---'

(prettier/prettier)

---

117-121: Format the authors array to comply with Prettier guidelines

The authors array formatting does not align with Prettier's style rules, which can affect code readability.

Apply this diff to reformat the array:

-  authors: [
-    { name: 'John' },
-    { photo: 'jane.jpg' },
-    { name: 'Bob', photo: 'bob.jpg', link: 'not-a-url' },
-  ],
+  authors: [{ name: 'John' }, { photo: 'jane.jpg' }, { name: 'Bob', photo: 'bob.jpg', link: 'not-a-url' }],

🧰 Tools

🪛 eslint

[error] 117-121: Replace ⏎········{·name:·'John'·},⏎········{·photo:·'jane.jpg'·},⏎········{·name:·'Bob',·photo:·'bob.jpg',·link:·'not-a-url'·},⏎······], with {·name:·'John'·},·{·photo:·'jane.jpg'·},·{·name:·'Bob',·photo:·'bob.jpg',·link:·'not-a-url'·}]

(prettier/prettier)

---

151-153: Simplify the expect statement formatting

The expect statement can be reformatted to improve readability and comply with style guidelines.

Apply this diff:

- expect(mockConsoleLog).toHaveBeenCalledWith(
-   expect.stringContaining('Errors in file invalid.md:'),
- );
+ expect(mockConsoleLog).toHaveBeenCalledWith(expect.stringContaining('Errors in file invalid.md:'));

🧰 Tools

🪛 eslint

[error] 151-153: Replace ⏎······expect.stringContaining('Errors·in·file·invalid.md:'),⏎···· with expect.stringContaining('Errors·in·file·invalid.md:')

(prettier/prettier)

scripts/markdown/check-markdown.js (4)

145-150: Improve function parameter formatting for readability

The parameters of the checkMarkdownFiles function can be formatted on a single line to enhance readability.

Apply this diff:

- async function checkMarkdownFiles(
-   folderPath,
-   validateFunction,
-   limit,
-   relativePath = ''
- ) {
+ async function checkMarkdownFiles(folderPath, validateFunction, limit, relativePath = '') {

🧰 Tools

🪛 eslint

[error] 145-150: Replace ⏎··folderPath,⏎··validateFunction,⏎··limit,⏎··relativePath·=·''⏎ with folderPath,·validateFunction,·limit,·relativePath·=·''

(prettier/prettier)

---

166-171: Simplify recursive function call formatting

The recursive call to checkMarkdownFiles can be formatted on a single line for better readability.

Apply this diff:

- await checkMarkdownFiles(
-   filePath,
-   validateFunction,
-   limit,
-   relativeFilePath
- );
+ await checkMarkdownFiles(filePath, validateFunction, limit, relativeFilePath);

🧰 Tools

🪛 eslint

[error] 166-171: Replace ⏎··········filePath,⏎··········validateFunction,⏎··········limit,⏎··········relativeFilePath⏎········ with filePath,·validateFunction,·limit,·relativeFilePath

(prettier/prettier)

---

173-173: Add a space after try keyword

Adding a space after the try keyword enhances code readability.

Apply this diff:

- try{
+ try {

🧰 Tools

🪛 eslint

[error] 173-173: Insert ·

(prettier/prettier)

---

185-185: Insert a space after }catch

For consistency and readability, add a space between } and catch.

Apply this diff:

- }catch (error) {
+ } catch (error) {

🧰 Tools

🪛 eslint

[error] 185-185: Insert ·

(prettier/prettier)

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

#!/bin/bash
# Description: Search for usages of 'fast-xml-parser' in the codebase.

# Test: Find all import statements using 'fast-xml-parser'.
# Expect: Only files that require it for development tasks.

rg "require\('fast-xml-parser'\)|import.+from 'fast-xml-parser'"

#!/bin/bash
# Check the content of the test file to understand how fast-xml-parser is used
cat tests/build-rss.test.js

#!/bin/bash
# Check the content of the RSS build script
cat scripts/build-rss.js

scripts/markdown/check-markdown.js (3)

10-36: Consider extracting magic numbers as named constants.

The implementation is robust, but readability could be improved by extracting magic numbers into named constants.

+const DEFAULT_CONCURRENCY_LIMIT = 10;
+
 function getConcurrencyLimit() {
   const envLimit = process.env.MARKDOWN_CONCURRENCY_LIMIT;
 
   // If no env var is set, return default
   if (envLimit === undefined) {
-    return 10;
+    return DEFAULT_CONCURRENCY_LIMIT;
   }
 
   // Attempt to parse the environment variable
   const parsedLimit = parseInt(envLimit, 10);
 
   // Validate the parsed limit
   if (Number.isNaN(parsedLimit)) {
     console.warn(`Invalid MARKDOWN_CONCURRENCY_LIMIT: '${envLimit}'. Value must be a number. Falling back to default of 10.`);
-    return 10;
+    return DEFAULT_CONCURRENCY_LIMIT;
   }
 
   // Check for non-positive integers
   if (parsedLimit <= 0) {
     console.warn(
       `MARKDOWN_CONCURRENCY_LIMIT must be a positive integer greater than 0. Received: ${parsedLimit}. Falling back to default of 10.`
     );
-    return 10;
+    return DEFAULT_CONCURRENCY_LIMIT;
   }
 
   return parsedLimit;
 }

🧰 Tools

🪛 eslint

[error] 23-23: Replace Invalid·MARKDOWN_CONCURRENCY_LIMIT:·'${envLimit}'.·Value·must·be·a·number.·Falling·back·to·default·of·10. with ⏎······Invalid·MARKDOWN_CONCURRENCY_LIMIT:·'${envLimit}'.·Value·must·be·a·number.·Falling·back·to·default·of·10.⏎····

(prettier/prettier)

---

145-184: Enhance error handling and documentation for concurrent processing.

While the implementation is good, consider adding:

1. Documentation about the concurrency behavior
2. Error handling specific to the concurrency limiter

 /**
  * Recursively checks markdown files in a folder and validates their frontmatter.
  * @param {string} folderPath - The path to the folder to check.
  * @param {Function} validateFunction - The function used to validate the frontmatter.
  * @param {string} [relativePath=''] - The relative path of the folder for logging purposes.
  * @param {import('p-limit').default} limit - Concurrency limiter.
+ * @throws {Error} When the concurrency limiter fails or when file operations fail
+ * @example
+ * // Process files with a concurrency limit of 5
+ * const limit = pLimit(5);
+ * await checkMarkdownFiles(folderPath, validateFn, limit);
  */

🧰 Tools

🪛 eslint

[error] 167-167: Delete ··

(prettier/prettier)

---

176-178: Enhance error messages with more context.

Consider improving error messages by including more context and using structured logging.

-          console.error(`Error processing file ${relativeFilePath}:`, error);
+          console.error(`Error processing markdown file ${relativeFilePath} (validation failed):`, {
+            error: error.message,
+            code: error.code,
+            stack: error.stack
+          });
           throw error;

-    console.error(`Error in directory ${folderPath}:`, err);
+    console.error(`Failed to process markdown files in directory ${folderPath}:`, {
+      error: err.message,
+      code: err.code,
+      stack: err.stack
+    });
     throw err;

-    console.error('Failed to validate markdown files:', error);
+    console.error('Markdown validation process failed:', {
+      error: error.message,
+      code: error.code,
+      stack: error.stack
+    });

Also applies to: 185-187, 207-209

tests/markdown/check-markdown.test.js (2)

72-109: Improve concurrency test reliability and readability.

The concurrency test could be more reliable and readable with these improvements:

1. Use a more descriptive test name
2. Add assertions for minimum concurrent executions
3. Use constants for test values

-    it('respects concurrency limit during file processing', async () => {
+    it('should process files concurrently while respecting the configured limit', async () => {
+      const CONCURRENCY_LIMIT = 5;
+      const TOTAL_FILES = 20;
+      const PROCESSING_TIME_MS = 50;
       let activeCount = 0;
       let maxActiveCount = 0;
       const mockValidateFunction = jest.fn().mockImplementation(async () => {
         activeCount++;
         try {
-          // Track the maximum number of concurrent executions
           if (activeCount > maxActiveCount) {
             maxActiveCount = activeCount;
           }
           
-          // Simulate some processing time
-          await new Promise(resolve => setTimeout(resolve, 50));
+          await new Promise(resolve => setTimeout(resolve, PROCESSING_TIME_MS));
         } finally {
           activeCount--;
         }
       });
     
       const writePromises = [];
-      for (let i = 0; i < 20; i++) {
+      for (let i = 0; i < TOTAL_FILES; i++) {
         writePromises.push(
           fs.writeFile(
             path.join(tempDir, `test${i}.md`),
             '---\ntitle: Test\n---'
           )
         );
       }
       await Promise.all(writePromises);
     
-      const limit = pLimit(5); // Set limit to 5
+      const limit = pLimit(CONCURRENCY_LIMIT);
       await checkMarkdownFiles(tempDir, mockValidateFunction, '', limit);
     
-      // Verify that the maximum number of concurrent executions never exceeds the limit
-      expect(maxActiveCount).toBeLessThanOrEqual(5);
+      // Verify concurrent execution bounds
+      expect(maxActiveCount).toBe(CONCURRENCY_LIMIT);
     
-      // Verify that the mock validate function was called for all files
-      expect(mockValidateFunction).toHaveBeenCalledTimes(20);
+      expect(mockValidateFunction).toHaveBeenCalledTimes(TOTAL_FILES);
     });

🧰 Tools

🪛 eslint

[error] 76-76: Unary operator '++' used.

(no-plusplus)

---

[error] 82-82: Delete ··········

(prettier/prettier)

---

[error] 84-84: Replace resolve with (resolve)

(prettier/prettier)

---

[error] 84-84: Return values from promise executor functions cannot be read.

(no-promise-executor-return)

---

[error] 86-86: Unary operator '--' used.

(no-plusplus)

---

[error] 89-89: Delete ····

(prettier/prettier)

---

[error] 91-91: Unary operator '++' used.

(no-plusplus)

---

[error] 92-97: Replace ⏎············fs.writeFile(⏎··············path.join(tempDir,·test${i}.md),⏎··············'---\ntitle:·Test\n---'⏎··········)⏎········ with fs.writeFile(path.join(tempDir,·test${i}.md),·'---\ntitle:·Test\n---')

(prettier/prettier)

---

[error] 100-100: Delete ····

(prettier/prettier)

---

[error] 103-103: Delete ····

(prettier/prettier)

---

[error] 106-106: Delete ····

(prettier/prettier)

---

153-170: Improve test organization and naming.

Consider organizing related test cases using nested describe blocks and more descriptive test names.

-  it('returns multiple validation errors for invalid blog frontmatter', async () => {
+  describe('Blog Frontmatter Validation', () => {
+    it('should return all validation errors when multiple fields are invalid', async () => {
       const frontmatter = {
         title: 123,
         date: 'invalid-date',
         type: 'blog',
         tags: 'not-an-array',
         cover: ['not-a-string'],
         authors: { name: 'John Doe' },
       };
       const errors = validateBlogs(frontmatter);
 
       expect(errors).toEqual([
         'Invalid date format: invalid-date',
         'Tags should be an array',
         'Cover must be a string',
         'Authors should be an array'
       ]);
-    });
+    });
+  });

🧰 Tools

🪛 eslint

[error] 160-160: Delete ,

(prettier/prettier)

---

[error] 168-168: Delete ,

(prettier/prettier)

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro

 function isValidURL(str) {
   try {
-    URL(str);
+    new URL(str);
     return true;
   } catch (err) {
     return false;
   }
 }

scripts/markdown/check-markdown.js (3)

8-38: Consider enhancing error handling and readability.

The function logic is sound, but could be improved:

+// Constants for configuration
+const DEFAULT_CONCURRENCY_LIMIT = 10;
+const MIN_CONCURRENCY_LIMIT = 1;
+
 function getConcurrencyLimit() {
   const envLimit = process.env.MARKDOWN_CONCURRENCY_LIMIT;
 
   if (envLimit === undefined) {
     return DEFAULT_CONCURRENCY_LIMIT;
   }
 
   const parsedLimit = parseInt(envLimit, 10);
 
   if (Number.isNaN(parsedLimit)) {
-    console.warn(`Invalid MARKDOWN_CONCURRENCY_LIMIT: '${envLimit}'. Value must be a number. Falling back to default of 10.`);
+    console.warn(`Invalid MARKDOWN_CONCURRENCY_LIMIT: '${envLimit}'. Expected a number, got ${typeof envLimit}. Falling back to default of ${DEFAULT_CONCURRENCY_LIMIT}.`);
     return DEFAULT_CONCURRENCY_LIMIT;
   }
 
-  if (parsedLimit <= 0) {
+  if (parsedLimit < MIN_CONCURRENCY_LIMIT) {
     console.warn(
-      `MARKDOWN_CONCURRENCY_LIMIT must be a positive integer greater than 0. Received: ${parsedLimit}. Falling back to default of 10.`
+      `MARKDOWN_CONCURRENCY_LIMIT must be a positive integer (>= ${MIN_CONCURRENCY_LIMIT}). Received: ${parsedLimit}. Falling back to default of ${DEFAULT_CONCURRENCY_LIMIT}.`
     );
     return DEFAULT_CONCURRENCY_LIMIT;
   }
 
   return parsedLimit;
 }

🧰 Tools

🪛 eslint

[error] 25-25: Replace Invalid·MARKDOWN_CONCURRENCY_LIMIT:·'${envLimit}'.·Value·must·be·a·number.·Falling·back·to·default·of·10. with ⏎······Invalid·MARKDOWN_CONCURRENCY_LIMIT:·'${envLimit}'.·Value·must·be·a·number.·Falling·back·to·default·of·10.⏎····

(prettier/prettier)

---

145-195: Consider refactoring for better maintainability.

The function handles multiple responsibilities and could benefit from separation of concerns.

Consider extracting the file processing logic into a separate function:

+async function processMarkdownFile(filePath, relativeFilePath, validateFunction) {
+  const fileContent = await fs.readFile(filePath, 'utf-8');
+  const { data: frontmatter } = matter(fileContent);
+  
+  const errors = validateFunction(frontmatter);
+  if (errors) {
+    console.log(`Errors in file ${relativeFilePath}:`);
+    errors.forEach((error) => console.log(` - ${error}`));
+    process.exitCode = 1;
+  }
+}
+
 async function checkMarkdownFiles(folderPath, validateFunction, limit, relativePath = '') {
   try {
     const files = await fs.readdir(folderPath);
     const filePromises = files.map(async (file) => {
       // ... existing path handling code ...
       
       if (stats.isDirectory()) {
         await checkMarkdownFiles(filePath, validateFunction, limit, relativeFilePath);
       } else if (path.extname(file) === '.md') {
         try {
-          await limit(async () => {
-            const fileContent = await fs.readFile(filePath, 'utf-8');
-            const { data: frontmatter } = matter(fileContent);
-            
-            const errors = validateFunction(frontmatter);
-            if (errors) {
-              console.log(`Errors in file ${relativeFilePath}:`);
-              errors.forEach((error) => console.log(` - ${error}`));
-              process.exitCode = 1;
-            }
-          });
+          await limit(() => processMarkdownFile(filePath, relativeFilePath, validateFunction));
         } catch (error) {
           console.error(`Error processing markdown file ${relativeFilePath}:`, {
             error: error.message,
             code: error.code,
             stack: error.stack
           });
           throw error;
         }
       }
     });
     
     await Promise.all(filePromises);
   } catch (err) {
     console.error(`Failed to process markdown files in directory ${folderPath}:`, {
       error: err.message,
       code: err.code,
       stack: err.stack
     });
     throw err;
   }
 }

🧰 Tools

🪛 eslint

[error] 167-167: Delete ··

(prettier/prettier)

---

201-221: Enhance error handling in main function.

The error handling could be more specific and informative.

 async function main() {
   try {
     const concurrencyLimit = getConcurrencyLimit();
     console.log(`Configured markdown processing with concurrency limit: ${concurrencyLimit}`);
 
     const limit = pLimit(concurrencyLimit);
 
     await Promise.all([
       checkMarkdownFiles(docsFolderPath, validateDocs, limit, ''),
       checkMarkdownFiles(blogsFolderPath, validateBlogs, limit, '')
     ]);
   } catch (error) {
     console.error('Markdown validation process failed:', {
+      message: 'Failed to validate markdown files. Check the error details below.',
       error: error.message,
       code: error.code,
+      path: error.path,
       stack: error.stack
     });
     process.exit(1);
   }
 }

tests/markdown/check-markdown.test.js (2)

72-111: Improve concurrency test reliability and readability.

The concurrency test could be more reliable and easier to understand.

 it('should process files concurrently while respecting the configured limit', async () => {
+  // Test configuration
   const CONCURRENCY_LIMIT = 5;
   const TOTAL_FILES = 20;
   const PROCESSING_TIME_MS = 50;
+  const TEST_CONTENT = '---\ntitle: Test\n---';
+
+  // Concurrency tracking
   let activeCount = 0;
   let maxActiveCount = 0;
+  let processedCount = 0;
+
   const mockValidateFunction = jest.fn().mockImplementation(async () => {
     activeCount++;
     try {
-      // Track the maximum number of concurrent executions
       if (activeCount > maxActiveCount) {
         maxActiveCount = activeCount;
       }
       
-      // Simulate some processing time
       await new Promise(resolve => setTimeout(resolve, PROCESSING_TIME_MS));
+      processedCount++;
     } finally {
       activeCount--;
     }
   });
 
+  // Create test files
   const writePromises = [];
   for (let i = 0; i < TOTAL_FILES; i++) {
     writePromises.push(
-      fs.writeFile(
-        path.join(tempDir, `test${i}.md`),
-        '---\ntitle: Test\n---'
-      )
+      fs.writeFile(path.join(tempDir, `test${i}.md`), TEST_CONTENT)
     );
   }
   await Promise.all(writePromises);
 
   const limit = pLimit(CONCURRENCY_LIMIT);
   await checkMarkdownFiles(tempDir, mockValidateFunction, limit, '');
 
-  // Verify concurrent execution bounds
   expect(maxActiveCount).toBe(CONCURRENCY_LIMIT);
-
   expect(mockValidateFunction).toHaveBeenCalledTimes(TOTAL_FILES);
+  expect(processedCount).toBe(TOTAL_FILES);
 });

🧰 Tools

🪛 eslint

[error] 79-79: Unary operator '++' used.

(no-plusplus)

---

[error] 85-85: Delete ··········

(prettier/prettier)

---

[error] 87-87: Replace resolve with (resolve)

(prettier/prettier)

---

[error] 87-87: Return values from promise executor functions cannot be read.

(no-promise-executor-return)

---

[error] 89-89: Unary operator '--' used.

(no-plusplus)

---

[error] 92-92: Delete ····

(prettier/prettier)

---

[error] 94-94: Unary operator '++' used.

(no-plusplus)

---

[error] 95-100: Replace ⏎············fs.writeFile(⏎··············path.join(tempDir,·test${i}.md),⏎··············'---\ntitle:·Test\n---'⏎··········)⏎········ with fs.writeFile(path.join(tempDir,·test${i}.md),·'---\ntitle:·Test\n---')

(prettier/prettier)

---

[error] 103-103: Delete ····

(prettier/prettier)

---

[error] 106-106: Delete ····

(prettier/prettier)

---

[error] 109-109: Delete ····

(prettier/prettier)

---

176-184: Enhance error test case assertions.

The error test case could have more specific assertions.

 it('logs error to console when an error occurs in checkMarkdownFiles', async () => {
   const invalidFolderPath = path.join(tempDir, 'non-existent-folder');
+  const expectedError = new Error('ENOENT');
 
   await expect(
     checkMarkdownFiles(invalidFolderPath, validateBlogs, '', pLimit(10)),
-  ).rejects.toThrow('ENOENT');
+  ).rejects.toThrow(expectedError);
 
-  expect(mockConsoleError.mock.calls[0][0]).toContain('Error in directory');
+  expect(mockConsoleError).toHaveBeenCalledWith(
+    expect.stringContaining('Failed to process markdown files in directory'),
+    expect.objectContaining({
+      error: expectedError.message,
+      code: 'ENOENT'
+    })
+  );
 });

🧰 Tools

🪛 eslint

[error] 179-181: Replace ⏎······checkMarkdownFiles(invalidFolderPath,·validateBlogs,·'',·pLimit(10)),⏎···· with checkMarkdownFiles(invalidFolderPath,·validateBlogs,·'',·pLimit(10))

(prettier/prettier)

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro